package Array;


public class MyArrays {
    /**
     * size与capacity
     * size是容器的大小，指得是容器中具体的元素个数 ，
     * capacity 容器的容量，指得是容器的大小,这个数不用定义，data.length就是
     */
    private int[] data; //创建的数组
    private int size; //数组具体的大小

    /*
     * 无参构造器
     * 如果没有传入参数，指定大小为10
     */
    public MyArrays(){
        this(10);
    }

    /*
     *@Param capacity 数组的容量，可以直接指定容器的大小
     */
    public MyArrays(int capacity){
        data = new int[capacity];
        //数组容器的容量，大小
        int size = 0;
    }
    /*
     * 如果传入的是一个静态数组
     */
    public MyArrays(int[] arrays){

        if (arrays.length>10){
            data = new int[arrays.length];
        }else{
            data = new int[10];
        }

        for (int i = 0; i < arrays.length ; i++) {
            data[i] = arrays[i];
            this.size++;
        }
    }
    /**
     * 获取数组的大小size
     */
    public int getSize(){
        return size;
    }

    /**
     * 获取数组的容量Capacity
     */
    public int getCapacity(){
        return data.length;
    }
    /**
     * 数组是否为空
     */
    public Boolean isEmpty(){
        return getSize() > 0;
    }

    /**
     * 向元素中指定位置增加元素方法
     */
    public void add(int index , int element){
        //怎么挪，需要索引为index的元素都往后挪一位，还不能从左边开始挪，不然右边的值就被覆盖了，所以要从后面挪
        if (data.length == size ){
            throw new IllegalArgumentException("数组越界");
        }
        //我们还要判断index是否合法（大于等于0，并且小于data.length）
        if (index < 0 || index > data.length){
            throw new IllegalArgumentException("索引不合法");
        }
        //for循环 中间是否等于，取决于是否需要操作索引等于index的那个数
        for (int i = size-1 ; i >=index ; i--) {
            //直到最后index索引上的数被移到下一个上
            data[i+1] = data[i];
        }
        data[index] = element;
        size++;

    }
    /**
     * 增加元素方法(头插法)
     */
    public void addFirst( int element)  {
        add(0 ,element);
    }
    /**
     * 增加元素方法(尾插法)
     */
    public void addLast( int element)  {
        add(size ,element);
    }
    /**
     * 返回数组是否包含此元素
     */
    public Boolean isContain(int element){
        if (getIndex(element) > 0){
            return true;
        }
        return false;
    }

    /**
     * 返回该数字在数组的索引
     */
    public int getIndex(int element) {
        for (int i = 0; i < size; i++) {
            if (data[i] == element) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 删除元素方法(根据元素删除)
     * @return
     */
    public void delete(int element){
        //先返回该元素的索引，然后根据索引删除
        int index = getIndex(element);
        if (index<0){
            throw new NullPointerException("该元素不存在");
        }
        deleteByID(index);

    }
    /**
     * 删除元素方法(根据索引删除)
     */
    public void deleteByID( int index ){
        //判断index是否合法(大于等于0 并且 小于等于 数组的大小
        if (index<0 || index>size) {
            throw new IllegalArgumentException("索引不合法");
        }
        //删除索引上的元素，只需要索引后面的元素统一向前覆盖一个就可以了
        for (int i = index; i < size ; i++) {
            data[index+1] = data[index];
        }
        size--;

    }
    /**
     * 修改元素方法
     */
    public void update(int index,int element){
        data[index] = element;
    }
    /**
     * 查询全部元素方法
     */
    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("Array :size = "+ size + ",capacity ="+getCapacity() + "          ");
        if (size==0){
            res.append("数组现在还是空的");
            return res.toString();
        }
        res.append("数组具体为：[");
        for (int i = 0; i <size ; i++) {
            res.append(data[i]);
            if (i != size-1){
                res.append(",");
            }else{
                res.append("]");
            }
        }
        return res.toString();
    }
}
